/*
调用 fs.createReadStream(path,options)
里面其实就是 return new ReadStream(path,options)
而ReadStream这个类实际继承于Readable这个类

Readable这个类上有一个方法read，它会调用子类的_read方法

也就是说只要子类实现一个_read方法，当我们on data的时候就会从这个_read方法里拿数据
在我们的_read方法里 可以通过this.push来发布data事件

push里传递的数据就是我们on data接受的数据

如果push为null 就会触发end事件

node里的http、request、response都是这么来的
*/
const {Readable,Writable,Duplex,Transform} = require('stream');
const fs = require('fs');
const path = require('path');

const resolve = (filename) => {
  return path.resolve(__dirname, filename);
};

/*
class MyReadStream extends Readable{
  constructor(){
    super();
    this.index = 0;
  }
  _read(){
    if(this.index === 0){
      let r = fs.readFileSync(resolve('a.txt'));
      this.push(r);
      this.index = -1;
    }else{
      this.push(null); //如果push null就会触发end事件
    }
  }
}

let x = new MyReadStream();

x.on('data', data => {
  console.log('data:',data);
});

x.on('end', data => {
  console.log('end:',data);
});
*/


/*
createWriteStream和createReadStream是一个思路
*/

/*class MyWriteStream extends Writable {
  _write(chunk, encoding, callback) {
    //callback把我们的callback包了一层，添加了clearBuffer(查看WriteStream.js)
    console.log(chunk);
    callback(); //相当于再次调用_write，直到清空缓冲区，会触发drain
  }
}

let x = new MyWriteStream();
x.write('hello');
x.write('hello');
x.write('hello');
x.end('ok');*/



//双工流

/*class MyDuplex extends Duplex{
  _write(chunk, encoding, callback) {

  }
  _read(size) {

  }
}

let my = new MyDuplex();*/




//转化流(主要用于压缩)，可以把写入的转化成可读的

let crypto = require('crypto');
//createHash接受一个参数：algorithm。运算法则； 演算法； 计算程序
// crypto MD5摘要算法 不能反解 雪崩(只要内容有一点不一样，摘要结果就完全不一样) 长度固定
/*let r = crypto.createHash('md5').update('我爱你').digest('base64');
console.log(r);*/

//process.stdin 类似于-> rs = fs.createReadStream()，是一个自定义可独流的实例
/*process.stdin.on('data', function (data) {
  console.log(data);
  //↑↓等价
  process.stdout.write(data);
});*/
// process.stdout.write('hello'); //←等价于console.log() 同步的

// process.stdin.pipe(process.stdout); //类别4.pipe.js


//我们现在有一个需求，把输入的结果转成大写输出

class MyTransform extends Transform{
  _transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    //将输入"加密"后输出
    // this.push(crypto.createHash('md5').update(chunk).digest('base64'));
    callback(); //清空缓存区 查看上面的_write 类比WriteStream.js 里的callback // 这里就是相当于再次调用_transform
  }
}

let transform = new MyTransform();
//transform是个转化流，既充当读又充当写
process.stdin.pipe(transform).pipe(process.stdout);




// 判断是不是一个流
let Stream = require('stream');
console.log(transform instanceof Stream); //true
console.log({} instanceof Stream); //false
